package com.itgacl.magic4j.libcommon.util;

import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.time.DateFormatUtils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;

/**
 * 日期工具类, 继承org.apache.commons.lang.time.DateUtils类
 *
 * @author 徐达沛
 */
public class DateUtils extends org.apache.commons.lang3.time.DateUtils {

    private static String[] parsePatterns = {
            "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM", "yyyy/MM/dd",
            "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM", "yyyy.MM.dd",
            "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM", "yyyyMMddHHmmss", "yyyyMMdd"
    };

    /**
     * 得到当前日期字符串 格式（yyyy-MM-dd）
     */
    public static String getDate() {
        return getDate("yyyy-MM-dd");
    }

    /**
     * 得到当前日期字符串 格式（yyyy-MM-dd） pattern可以为："yyyy-MM-dd" "HH:mm:ss" "E"
     */
    public static String getDate(String pattern) {
        return DateFormatUtils.format(new Date(), pattern);
    }

    /**
     * 获取当前时间戳
     *
     * @return
     */
    public static long currentTimeMillis() {
        return System.currentTimeMillis();
    }

    /**
     * 得到日期字符串 默认格式（yyyy-MM-dd） pattern可以为："yyyy-MM-dd" "HH:mm:ss" "E"
     */
    public static String formatDate(Date date, Object... pattern) {
        String formatDate;
        if (pattern != null && pattern.length > 0) {
            formatDate = DateFormatUtils.format(date, pattern[0].toString());
        } else {
            formatDate = DateFormatUtils.format(date, "yyyy-MM-dd HH:mm:ss");
        }
        return formatDate;
    }

    /**
     * 得到日期时间字符串，转换格式（yyyy-MM-dd HH:mm:ss）
     */
    public static String formatDateTime(Date date) {
        return formatDate(date, "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 得到当前时间字符串 格式（HH:mm:ss）
     */
    public static String getTime() {
        return formatDate(new Date(), "HH:mm:ss");
    }

    /**
     * 得到当前日期和时间字符串 格式（yyyy-MM-dd HH:mm:ss）
     */
    public static String getDateTime() {
        return formatDate(new Date(), "yyyy-MM-dd HH:mm:ss");
    }

    /**
     * 得到当前年份字符串 格式（yyyy）
     */
    public static int getYear() {
        return getYear(new Date());
    }

    /**
     * 获得指定日期年份
     *
     * @param date
     * @return
     */
    public static int getYear(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.YEAR);
    }

    /**
     * 得到当前月份字符串 格式（MM）
     */
    public static int getMonth() {
        return getMonth(new Date());
    }

    public static int getMonth(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.MONTH);
    }

    /**
     * 得到当天字符串 格式（dd）
     */
    public static int getDay() {
        return getDay(new Date());
    }

    public static int getDay(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.DATE);
    }

    public static int getHour() {
        return getHour(new Date());
    }

    public static int getHour(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.HOUR);
    }


    /**
     * 得到当前星期字符串 格式（E）星期几
     */
    public static String getWeek() {
        return formatDate(new Date(), "E");
    }

    /**
     * 日期型字符串转化为日期 格式 { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm",
     * "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy.MM.dd",
     * "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm" }
     */
    public static Date parseDate(Object str) {
        if (str == null) {
            return null;
        }
        try {
            return parseDate(str.toString(), parsePatterns);
        } catch (ParseException e) {
            return null;
        }
    }

    /**
     * 获取过去的天数
     *
     * @param date
     * @return
     */
    public static long pastDays(Date date) {
        long t = new Date().getTime() - date.getTime();
        return t / (24 * 60 * 60 * 1000);
    }

    /**
     * 获取过去的小时
     *
     * @param date
     * @return
     */
    public static long pastHour(Date date) {
        long t = new Date().getTime() - date.getTime();
        return t / (60 * 60 * 1000);
    }

    /**
     * 获取过去的分钟
     *
     * @param date
     * @return
     */
    public static long pastMinutes(Date date) {
        long t = new Date().getTime() - date.getTime();
        return t / (60 * 1000);
    }

    /**
     * 获取过去的毫秒
     *
     * @param date
     * @return
     */
    public static long pastMillisecond(Date date) {
        long t = new Date().getTime() - date.getTime();
        return t;
    }

    /**
     * 获取过去的秒
     *
     * @param date
     * @return
     */
    public static long pastSecond(Date date) {
        long t = new Date().getTime() - date.getTime();
        return t / 1000;
    }

    /**
     * 转换为时间（天,时:分:秒.毫秒）
     *
     * @param timeMillis
     * @return
     */
    public static String formatDateTime(long timeMillis) {
        long day = timeMillis / (24 * 60 * 60 * 1000);
        long hour = (timeMillis / (60 * 60 * 1000) - day * 24);
        long min = ((timeMillis / (60 * 1000)) - day * 24 * 60 - hour * 60);
        long s = (timeMillis / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - min * 60);
        long sss = (timeMillis - day * 24 * 60 * 60 * 1000 - hour * 60 * 60 * 1000 - min * 60 * 1000
                - s * 1000);
        return (day > 0 ? day + "," : "") + hour + ":" + min + ":" + s + "." + sss;
    }

    /**
     * 得到当天的开始时间 （yyyy-MM-dd 00:00:00）
     */
    public static Date getStartForDay() {
        return getStartForDay(new Date());
    }

    /**
     * 得到指定日期当天的开始时间 （yyyy-MM-dd 00:00:00.000）
     */
    public static Date getStartForDay(Date date) {
        Calendar todayStart = Calendar.getInstance();
        todayStart.setTime(date);
        todayStart.set(Calendar.HOUR_OF_DAY, 0);
        todayStart.set(Calendar.MINUTE, 0);
        todayStart.set(Calendar.SECOND, 0);
        todayStart.set(Calendar.MILLISECOND, 0);
        return todayStart.getTime();
    }

    /**
     * 得到当天的结束开始时间 （yyyy-MM-dd 23:59:59.999）
     */
    public static Date getEndForDay() {
        return getEndForDay(new Date());
    }

    /**
     * 得到指定日期当天的结束时间 （yyyy-MM-dd 23:59:59.999）
     */
    public static Date getEndForDay(Date date) {
        Calendar todayEnd = Calendar.getInstance();
        todayEnd.setTime(date);
        todayEnd.set(Calendar.HOUR_OF_DAY, 23);
        todayEnd.set(Calendar.MINUTE, 59);
        todayEnd.set(Calendar.SECOND, 59);
        todayEnd.set(Calendar.MILLISECOND, 999);
        return todayEnd.getTime();
    }

    /**
     * 得到当天的结束开始时间 （yyyy-MM-dd 23:59:59.999）
     */
    public static Date getEndDateTimeForDay() {
        return getEndDateTimeForDay(new Date());
    }

    /**
     * 得到指定日期当天的结束时间 （yyyy-MM-dd 23:59:59.0）
     */
    public static Date getEndDateTimeForDay(Date date) {
        Calendar todayEnd = Calendar.getInstance();
        todayEnd.setTime(date);
        todayEnd.set(Calendar.HOUR_OF_DAY, 23);
        todayEnd.set(Calendar.MINUTE, 59);
        todayEnd.set(Calendar.SECOND, 59);
        todayEnd.set(Calendar.MILLISECOND, 0);
        return todayEnd.getTime();
    }

    /**
     * 得到指定日期当天的开始时间 （yyyy-MM-01 00:00:00.000）
     */
    public static Date getStartOfMonth(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 得到指定日期当天的结束时间 （yyyy-MM-dd 23:59:59.0）
     */
    public static Date getEndDateTimeOfMonth(Date date) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MONTH, 1);
        calendar.set(Calendar.DAY_OF_MONTH, 0);
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 0);
        return calendar.getTime();
    }

    /**
     * 获取两个日期之间的天数
     *
     * @param before
     * @param after
     * @return
     */
    public static double getDistanceOfTwoDate(Date before, Date after) {
        long beforeTime = before.getTime();
        long afterTime = after.getTime();
        return (afterTime - beforeTime) / (1000 * 60 * 60 * 24);
    }

    /**
     * <li>功能描述：时间相减得到天数
     *
     * @param beginDateStr
     * @param endDateStr
     * @return long
     */
    public static long getDaySub(String beginDateStr, String endDateStr) {
        long day = 0;
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date beginDate;
        Date endDate;
        try {
            beginDate = format.parse(beginDateStr);
            endDate = format.parse(endDateStr);
            day = (endDate.getTime() - beginDate.getTime()) / (24 * 60 * 60 * 1000);
            //System.out.println("相隔的天数="+day);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return day;
    }

    /**
     * 返回当前字符串型日期
     *
     * @return String 返回的字符串型日期
     */
    public static String getCurDate() {
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat simpledateformat = new SimpleDateFormat("yyyy-MM-dd");
        String strDate = simpledateformat.format(calendar.getTime());
        return strDate;
    }

    /**
     * 返回当前字符串型日期
     *
     * @return String 返回的字符串型日期
     */
    public static Date getCurDate(String format) throws ParseException {
        Calendar calendar = Calendar.getInstance();
        SimpleDateFormat simpledateformat = new SimpleDateFormat(format);
        String strDate = simpledateformat.format(calendar.getTime());
        return parseDate(strDate, format);
    }

    /***
     * 日期减一天、加一天
     *
     * @param option
     *            传入类型 pro：日期减一天，next：日期加一天
     * @param _date
     *            2014-11-24
     * @return 减一天：2014-11-23或(加一天：2014-11-25)
     */
    public static String checkOption(String option, String _date) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Calendar cl = Calendar.getInstance();
        Date date = null;
        try {
            date = (Date) sdf.parse(_date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        cl.setTime(date);
        if ("pre".equals(option)) {
            // 时间减一天
            cl.add(Calendar.DAY_OF_MONTH, -1);

        } else if ("next".equals(option)) {
            // 时间加一天
            cl.add(Calendar.DAY_OF_YEAR, 1);
        } else {
            // do nothing
        }
        date = cl.getTime();
        return sdf.format(date);
    }

    /**
     * 获取传入参数类型yyyy-MM的日期格式，并返回相同格式下个月的字符串
     *
     * @param month
     * @return
     */
    public static String nextMonth(String month) {
        String[] arr = month.split("-");
        if (arr.length >= 2) {
            //输入的是12月份
            if ("12".equals(arr[1])) {
                //当前年份加1，当前月份变为1
                arr[1] = "1";
            } else {
                //其它月份只需要月份加1
                int newMonth = Integer.parseInt(arr[1]) + 1;
                arr[1] = String.valueOf(newMonth);
            }
            return arr[0] + "-" + arr[1];
        } else {
            return month;
        }
    }

    /**
     * 返回汉语星期
     *
     * @param date
     * @return
     */
    public static String getWeekOfDate(Date date) {
        String[] weekOfDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        Calendar calendar = Calendar.getInstance();
        if (date != null) {
            calendar.setTime(date);
        }
        int w = calendar.get(Calendar.DAY_OF_WEEK) - 1;
        if (w < 0) {
            w = 0;
        }
        return weekOfDays[w];
    }

    /**
     * 判断日期是否为当天
     *
     * @param date
     * @return
     */
    public static boolean isToday(Date date) {
        Calendar c1 = Calendar.getInstance();
        c1.setTime(date);
        int year1 = c1.get(Calendar.YEAR);
        int month1 = c1.get(Calendar.MONTH) + 1;
        int day1 = c1.get(Calendar.DAY_OF_MONTH);
        Calendar c2 = Calendar.getInstance();
        c2.setTime(new Date());
        int year2 = c2.get(Calendar.YEAR);
        int month2 = c2.get(Calendar.MONTH) + 1;
        int day2 = c2.get(Calendar.DAY_OF_MONTH);
        return year1 == year2 && month1 == month2 && day1 == day2;
    }

    /**
     * gu.获取当前日指定分
     *
     * @param minute 分
     * @return yyyy-MM-dd HH:mm:ss
     */
    public static String getCurrentDayAssignMinute(int minute) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.MINUTE, minute);// 整分
        calendar.set(Calendar.SECOND, 0);// 整秒
        return format.format(calendar.getTime());
    }

    /**
     * gu.返回传入时间 年月日 时分秒格式日期的毫秒值
     */
    public static long getDateTime(String date) {
        SimpleDateFormat sdff = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date da = null;
        try {
            da = sdff.parse(date);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return da.getTime();
    }

    /**
     * gu.返回传入时间 年月日 时分秒格式日期的毫秒值
     */
    public static long getDateTimePoke(String date) {
        SimpleDateFormat sdff = new SimpleDateFormat("yyyyMMddHHmmss");
        Date da = null;
        try {
            da = sdff.parse(date);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return da.getTime();
    }

    /**
     * gu.LocalDateTime to yyyy-MM-dd HH:mm:ss
     */
    public static String localDateTimeToStr(LocalDateTime localDateTime) {
        String format = "YYYY-MM-dd hh:mm:ss";
        return localDateTime.format(DateTimeFormatter.ofPattern(format));
    }

    /**
     * gu.LocalDateTime to yyyyMMdd
     */
    public static String localDateTimeToStrDayPoke(LocalDateTime localDateTime) {
        String format = "yyyyMMdd";
        return localDateTime.format(DateTimeFormatter.ofPattern(format));
    }


    /**
     * gu.时间格式转换
     * yyyy-MM-dd HH:mm:ss to yyyyMMddHHmmss
     */
    public static String dateTimeToDateTimePoke(String date) {
        // 转换成毫秒
        long currentTime = getDateTime(date);

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMddHHmmss");

        Date dateTime = new Date();

        dateTime.setTime(currentTime);

        return simpleDateFormat.format(dateTime);
    }

    /**
     * gu.时间格式转换
     * yyyyMMddHHmmss to yyyy-MM-dd HH:mm:ss
     */
    public static String dateTimePokeToDateTime(String date) {
        // 转换成毫秒
        long currentTime = getDateTimePoke(date);

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        Date dateTime = new Date();

        dateTime.setTime(currentTime);

        return simpleDateFormat.format(dateTime);
    }

    /**
     * gu:东八区时间转换
     */
    public static LocalDateTime eastEightAreaDateTurn(String date) {
        return LocalDateTime.parse(date, DateTimeFormatter.ISO_ZONED_DATE_TIME);
    }

    /**
     * gu:datetimetolocalDatetime
     */
    public static LocalDateTime dateTimeToLocalDatetime(String date) {
        return LocalDateTime.parse(date, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }

    /**
     * gu:获取日期时间戳
     */
    public static String getDatePoke() {
        return new SimpleDateFormat("yyyyMMdd").format(new Date());
    }

    /**
     * Date转换为LocalDateTime
     */
    public static LocalDateTime dateToLocalDateTime(Date date) {
        Instant instant = date.toInstant();
        // 系统默认时区
        ZoneId zoneId = ZoneId.systemDefault();
        return instant.atZone(zoneId).toLocalDateTime();
    }

    /**
     * gu:获取指定日
     */
    public static String getAssignDayTime(Integer day) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Calendar c = Calendar.getInstance();
        c.add(Calendar.DATE, day);// 1表示明天,0表示当天
        return format.format(c.getTime());
    }

    /**
     * gu:localDateTime to yyyy-MM-dd
     */
    public static String localDateTimeToDay(LocalDateTime localDateTime) {
        return localDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    }


    /**
     * 获取当前时间戳
     */
    public static String getCurrentDateTimePoke() {
        return new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date());
    }

    public static String getCurrentTime() {
        return formatDate(new Date(), "yyyyMMddHHmmss");
    }

    /**
     * 获取时差：天
     */
    public static long getDay(LocalDateTime startTime, LocalDateTime endTime) {
        return getTimeDiff(startTime, endTime).toDays();
    }

    /**
     * 获取时差：时
     */
    public static long getHour(LocalDateTime startTime, LocalDateTime endTime) {
        return getTimeDiff(startTime, endTime).toHours();
    }

    /**
     * 获取时差：分
     */
    public static long getMinute(LocalDateTime startTime, LocalDateTime endTime) {
        return getTimeDiff(startTime, endTime).toMinutes();
    }

    /**
     * 获取时差：秒
     */
    public static long getSecond(LocalDateTime startTime, LocalDateTime endTime) {
        return getTimeDiff(startTime, endTime).getSeconds();
    }

    /**
     * 获取时差
     */
    public static Duration getTimeDiff(LocalDateTime startTime, LocalDateTime endTime) {
        if (ObjectUtils.anyNull(startTime, endTime)) {
            return Duration.ZERO;
        }
        return Duration.between(startTime, endTime);
    }


    /**
     * 根据传入时间 获取昨天的开始时间
     *
     * @param time
     * @return
     */
    public static String getLastDayStartDate(String time) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = format.parse(time);

        } catch (ParseException e) {
            e.printStackTrace();
        }
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.DATE, -1);//当前时间减一天

        return format.format(cal.getTime()) + " 00:00:00";
    }

    /**
     * 根据传入时间 获取昨天的结束时间
     *
     * @param time
     * @return
     */
    public static String getLastDayEndDate(String time) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = format.parse(time);

        } catch (ParseException e) {
            e.printStackTrace();
        }
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.DATE, -1);//当前时间减一天

        return format.format(cal.getTime()) + " 23:59:59";
    }

    /**
     * 根据传入时间 获取上周一
     *
     * @param time
     * @return
     */
    public static String getLastWeekMonday(String time) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = format.parse(time);

        } catch (ParseException e) {
            e.printStackTrace();
        }
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        if (1 == cal.get(Calendar.DAY_OF_WEEK)) {//判断当前日期是否为周末，因为周末是本周第一天，如果不向后推迟一天的到的将是下周一的零点，而不是本周周一零点
            cal.add(Calendar.DATE, -1);
        }
        cal.add(Calendar.DAY_OF_MONTH, -7);//时间减去7天
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);//Calendar.MONDAY 这个是周一的意思      想获取周几就更换这个

        return format.format(cal.getTime());
    }

    /**
     * 根据传入时间 获取上周一
     *
     * @param date
     * @return
     */
    public static String getLastWeekMonday(Date date, Object... pattern) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        if (pattern != null && pattern.length > 0) {
            format = new SimpleDateFormat(pattern[0].toString());
        }
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        if (1 == cal.get(Calendar.DAY_OF_WEEK)) {//判断当前日期是否为周末，因为周末是本周第一天，如果不向后推迟一天的到的将是下周一的零点，而不是本周周一零点
            cal.add(Calendar.DATE, -1);
        }
        cal.add(Calendar.DAY_OF_MONTH, -7);//时间减去7天
        cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);//Calendar.MONDAY 这个是周一的意思      想获取周几就更换这个

        return format.format(cal.getTime());
    }

    /**
     * 根据传入时间 获取上周周天
     *
     * @param time
     * @return
     */
    public static String getLastWeekSunday(String time) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = format.parse(time);

        } catch (ParseException e) {
            e.printStackTrace();
        }
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);

        if (1 == cal.get(Calendar.DAY_OF_WEEK)) {//判断当前日期是否为周末，因为周末是本周第一天，如果不向后推迟一天的到的将是下周一的零点，而不是本周周一零点
            cal.add(Calendar.DATE, -1);
        }
        cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);//Calendar.SUNDAY 周天想获取周几就更换这个
        return format.format(cal.getTime());
    }

    /**
     * 根据传入时间 获取上周周天
     *
     * @param date
     * @return
     */
    public static String getLastWeekSunday(Date date, Object... pattern) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        if (pattern != null && pattern.length > 0) {
            format = new SimpleDateFormat(pattern[0].toString());
        }
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);

        if (1 == cal.get(Calendar.DAY_OF_WEEK)) {//判断当前日期是否为周末，因为周末是本周第一天，如果不向后推迟一天的到的将是下周一的零点，而不是本周周一零点
            cal.add(Calendar.DATE, -1);
        }
        cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);//Calendar.SUNDAY 周天想获取周几就更换这个
        return format.format(cal.getTime());
    }


    /**
     * 根据传入时间获取上月第一天
     *
     * @param time
     * @return
     */
    public static String getLastMonthFirstDate(String time) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date date;
        String monthFirstDate = "";
        try {
            date = format.parse(time);
            Calendar c = Calendar.getInstance();
            //设置为指定日期
            c.setTime(date);
            //指定日期月份减去一
            c.add(Calendar.MONTH, -1);
            //指定日期月份减去一后的 获取第一天
            c.set(Calendar.DAY_OF_MONTH, c.getActualMinimum(Calendar.DAY_OF_MONTH));
            //获取最终的时间
            Date lastDateOfPrevMonth = c.getTime();
            monthFirstDate = format.format(lastDateOfPrevMonth);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return monthFirstDate;
    }

    /**
     * 根据传入时间获取上月第一天
     *
     * @param date
     * @return
     */
    public static String getLastMonthFirstDate(Date date) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String monthFirstDate = "";
        try {
            Calendar c = Calendar.getInstance();
            //设置为指定日期
            c.setTime(date);
            //指定日期月份减去一
            c.add(Calendar.MONTH, -1);
            //指定日期月份减去一后的 获取第一天
            c.set(Calendar.DAY_OF_MONTH, c.getActualMinimum(Calendar.DAY_OF_MONTH));
            //获取最终的时间
            Date lastDateOfPrevMonth = c.getTime();
            monthFirstDate = format.format(lastDateOfPrevMonth);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return monthFirstDate;
    }

    /**
     * 根据传入时间 获取上月最后一天
     *
     * @param time
     * @return
     */
    public static String getLastMonthEndDate(String time) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date date;
        String monthFirstDate = "";
        try {
            date = format.parse(time);
            Calendar c = Calendar.getInstance();
            //设置为指定日期
            c.setTime(date);
            //指定日期月份减去一
            c.add(Calendar.MONTH, -1);
            //指定日期月份减去一后的 最大天数
            c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
            //获取最终的时间
            Date lastDateOfPrevMonth = c.getTime();
            monthFirstDate = format.format(lastDateOfPrevMonth);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return monthFirstDate;
    }

    /**
     * 根据传入时间 获取上月最后一天
     *
     * @param date
     * @return
     */
    public static String getLastMonthEndDate(Date date) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        String monthFirstDate = "";
        try {
            Calendar c = Calendar.getInstance();
            //设置为指定日期
            c.setTime(date);
            //指定日期月份减去一
            c.add(Calendar.MONTH, -1);
            //指定日期月份减去一后的 最大天数
            c.set(Calendar.DATE, c.getActualMaximum(Calendar.DATE));
            //获取最终的时间
            Date lastDateOfPrevMonth = c.getTime();
            monthFirstDate = format.format(lastDateOfPrevMonth);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return monthFirstDate;
    }

    /**
     * 设定一个日期时间，加几分钟（小时或者天）后得到新的日期
     *
     * @param day
     * @param minute
     * @return
     */
    public static Date addDateMinute(String day, int minute) {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 24小时制
        Date date = null;
        try {
            date = format.parse(day);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        if (date == null)
            return null;
        return addDateMinute(date, minute);
    }

    /**
     * 设定一个日期时间，加几分钟后得到新的日期
     *
     * @param date
     * @param minute
     * @return
     */
    public static Date addDateMinute(Date date, int minute) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        cal.add(Calendar.MINUTE, minute);// 24小时制
        date = cal.getTime();
        return date;
    }


    /**
     * 获取本地日期时间对象
     *
     * @param timestamp 时间戳
     * @return 本地日期时间对象
     */
    private static LocalDateTime ofEpochSecond(long timestamp) {
        return LocalDateTime.ofEpochSecond(timestamp / 1000L, 0, ZoneOffset.ofHours(8));
    }

    /**
     * 重载 {@link #ofEpochSecond(long)}
     *
     * @return 本地日期时间对象
     */
    private static LocalDateTime ofEpochSecond() {
        return ofEpochSecond(System.currentTimeMillis());
    }


    /**
     * 年-月-日 时:分:秒
     */
    private static final DateTimeFormatter YYYY_MM_DD_HH_MM_SS_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

    /**
     * 格式化输出时间戳
     * 该时间戳转换，线程安全，也无需反复创建时间转换对象资源。
     * 输出格式 yyyy-MM-dd HH:mm:ss.SSS
     *
     * @param timestamp 时间戳
     * @return 格式化之后的时间戳
     */
    public static String formatTime(long timestamp) {
        return StringUtil.formatMsg("{}.{}", ofEpochSecond(timestamp).format(YYYY_MM_DD_HH_MM_SS_FORMATTER), timestamp % 1000L);
    }

    /**
     * 格式化输出时间
     * 重载见 {@link #formatTime(long)}
     *
     * @param date 时间
     * @return 格式化之后的时间
     */
    public static String formatTime(Date date) {
        return formatTime(date.getTime());
    }


    /**
     * 格式化输出当前时间
     * 重载见 {@link #formatTime(long)}
     *
     * @return 格式化之后的当前时间
     */
    public static String formatTime() {
        return formatTime(System.currentTimeMillis());
    }

    /**
     * 年-月
     */
    private static final DateTimeFormatter YYYY_MM_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM");

    /**
     * 获取年月日期字符串
     * 格式 yyyy-MM
     *
     * @return 年月日期字符串
     */
    public static String yearMonth() {
        return ofEpochSecond().format(YYYY_MM_FORMATTER);
    }


    /**
     * 年-月-日
     */
    private static final DateTimeFormatter YYYY_MM_DD_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");

    /**
     * 获取年月日日期字符串
     * 格式 yyyy-MM-dd
     *
     * @return 年月日日期字符串
     */
    public static String yearMonthDay() {
        return ofEpochSecond().format(YYYY_MM_DD_FORMATTER);
    }


}
